home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / TreeMap.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  13.4 KB  |  905 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7.  
  8. public class TreeMap<K, V> extends AbstractMap<K, V> implements NavigableMap<K, V>, Cloneable, Serializable {
  9.    private final Comparator<? super K> comparator;
  10.    private transient Entry<K, V> root = null;
  11.    private transient int size = 0;
  12.    private transient int modCount = 0;
  13.    private transient TreeMap<K, V>.EntrySet entrySet = null;
  14.    private transient KeySet<K> navigableKeySet = null;
  15.    private transient NavigableMap<K, V> descendingMap = null;
  16.    private static final boolean RED = false;
  17.    private static final boolean BLACK = true;
  18.    private static final long serialVersionUID = 919286545866124006L;
  19.  
  20.    public TreeMap() {
  21.       this.comparator = null;
  22.    }
  23.  
  24.    public TreeMap(Comparator<? super K> var1) {
  25.       this.comparator = var1;
  26.    }
  27.  
  28.    public TreeMap(Map<? extends K, ? extends V> var1) {
  29.       this.comparator = null;
  30.       this.putAll(var1);
  31.    }
  32.  
  33.    public TreeMap(SortedMap<K, ? extends V> var1) {
  34.       this.comparator = var1.comparator();
  35.  
  36.       try {
  37.          this.buildFromSorted(var1.size(), var1.entrySet().iterator(), (ObjectInputStream)null, (Object)null);
  38.       } catch (IOException var3) {
  39.       } catch (ClassNotFoundException var4) {
  40.       }
  41.  
  42.    }
  43.  
  44.    public int size() {
  45.       return this.size;
  46.    }
  47.  
  48.    public boolean containsKey(Object var1) {
  49.       return this.getEntry(var1) != null;
  50.    }
  51.  
  52.    public boolean containsValue(Object var1) {
  53.       for(Entry var2 = this.getFirstEntry(); var2 != null; var2 = successor(var2)) {
  54.          if (valEquals(var1, var2.value)) {
  55.             return true;
  56.          }
  57.       }
  58.  
  59.       return false;
  60.    }
  61.  
  62.    public V get(Object var1) {
  63.       Entry var2 = this.getEntry(var1);
  64.       return (V)(var2 == null ? null : var2.value);
  65.    }
  66.  
  67.    public Comparator<? super K> comparator() {
  68.       return this.comparator;
  69.    }
  70.  
  71.    public K firstKey() {
  72.       return (K)key(this.getFirstEntry());
  73.    }
  74.  
  75.    public K lastKey() {
  76.       return (K)key(this.getLastEntry());
  77.    }
  78.  
  79.    public void putAll(Map<? extends K, ? extends V> var1) {
  80.       int var2 = var1.size();
  81.       if (this.size == 0 && var2 != 0 && var1 instanceof SortedMap) {
  82.          Comparator var3 = ((SortedMap)var1).comparator();
  83.          if (var3 == this.comparator || var3 != null && var3.equals(this.comparator)) {
  84.             ++this.modCount;
  85.  
  86.             try {
  87.                this.buildFromSorted(var2, var1.entrySet().iterator(), (ObjectInputStream)null, (Object)null);
  88.             } catch (IOException var5) {
  89.             } catch (ClassNotFoundException var6) {
  90.             }
  91.  
  92.             return;
  93.          }
  94.       }
  95.  
  96.       super.putAll(var1);
  97.    }
  98.  
  99.    final Entry<K, V> getEntry(Object var1) {
  100.       if (this.comparator != null) {
  101.          return this.getEntryUsingComparator(var1);
  102.       } else if (var1 == null) {
  103.          throw new NullPointerException();
  104.       } else {
  105.          Comparable var2 = (Comparable)var1;
  106.          Entry var3 = this.root;
  107.  
  108.          while(var3 != null) {
  109.             int var4 = var2.compareTo(var3.key);
  110.             if (var4 < 0) {
  111.                var3 = var3.left;
  112.             } else {
  113.                if (var4 <= 0) {
  114.                   return var3;
  115.                }
  116.  
  117.                var3 = var3.right;
  118.             }
  119.          }
  120.  
  121.          return null;
  122.       }
  123.    }
  124.  
  125.    final Entry<K, V> getEntryUsingComparator(Object var1) {
  126.       Object var2 = var1;
  127.       Comparator var3 = this.comparator;
  128.       if (var3 != null) {
  129.          Entry var4 = this.root;
  130.  
  131.          while(var4 != null) {
  132.             int var5 = var3.compare(var2, var4.key);
  133.             if (var5 < 0) {
  134.                var4 = var4.left;
  135.             } else {
  136.                if (var5 <= 0) {
  137.                   return var4;
  138.                }
  139.  
  140.                var4 = var4.right;
  141.             }
  142.          }
  143.       }
  144.  
  145.       return null;
  146.    }
  147.  
  148.    final Entry<K, V> getCeilingEntry(K var1) {
  149.       Entry var2 = this.root;
  150.  
  151.       while(var2 != null) {
  152.          int var3 = this.compare(var1, var2.key);
  153.          if (var3 < 0) {
  154.             if (var2.left == null) {
  155.                return var2;
  156.             }
  157.  
  158.             var2 = var2.left;
  159.          } else {
  160.             if (var3 <= 0) {
  161.                return var2;
  162.             }
  163.  
  164.             if (var2.right == null) {
  165.                Entry var4 = var2.parent;
  166.  
  167.                for(Entry var5 = var2; var4 != null && var5 == var4.right; var4 = var4.parent) {
  168.                   var5 = var4;
  169.                }
  170.  
  171.                return var4;
  172.             }
  173.  
  174.             var2 = var2.right;
  175.          }
  176.       }
  177.  
  178.       return null;
  179.    }
  180.  
  181.    final Entry<K, V> getFloorEntry(K var1) {
  182.       Entry var2 = this.root;
  183.  
  184.       while(var2 != null) {
  185.          int var3 = this.compare(var1, var2.key);
  186.          if (var3 > 0) {
  187.             if (var2.right == null) {
  188.                return var2;
  189.             }
  190.  
  191.             var2 = var2.right;
  192.          } else {
  193.             if (var3 >= 0) {
  194.                return var2;
  195.             }
  196.  
  197.             if (var2.left == null) {
  198.                Entry var4 = var2.parent;
  199.  
  200.                for(Entry var5 = var2; var4 != null && var5 == var4.left; var4 = var4.parent) {
  201.                   var5 = var4;
  202.                }
  203.  
  204.                return var4;
  205.             }
  206.  
  207.             var2 = var2.left;
  208.          }
  209.       }
  210.  
  211.       return null;
  212.    }
  213.  
  214.    final Entry<K, V> getHigherEntry(K var1) {
  215.       Entry var2 = this.root;
  216.  
  217.       while(var2 != null) {
  218.          int var3 = this.compare(var1, var2.key);
  219.          if (var3 < 0) {
  220.             if (var2.left == null) {
  221.                return var2;
  222.             }
  223.  
  224.             var2 = var2.left;
  225.          } else {
  226.             if (var2.right == null) {
  227.                Entry var4 = var2.parent;
  228.  
  229.                for(Entry var5 = var2; var4 != null && var5 == var4.right; var4 = var4.parent) {
  230.                   var5 = var4;
  231.                }
  232.  
  233.                return var4;
  234.             }
  235.  
  236.             var2 = var2.right;
  237.          }
  238.       }
  239.  
  240.       return null;
  241.    }
  242.  
  243.    final Entry<K, V> getLowerEntry(K var1) {
  244.       Entry var2 = this.root;
  245.  
  246.       while(var2 != null) {
  247.          int var3 = this.compare(var1, var2.key);
  248.          if (var3 > 0) {
  249.             if (var2.right == null) {
  250.                return var2;
  251.             }
  252.  
  253.             var2 = var2.right;
  254.          } else {
  255.             if (var2.left == null) {
  256.                Entry var4 = var2.parent;
  257.  
  258.                for(Entry var5 = var2; var4 != null && var5 == var4.left; var4 = var4.parent) {
  259.                   var5 = var4;
  260.                }
  261.  
  262.                return var4;
  263.             }
  264.  
  265.             var2 = var2.left;
  266.          }
  267.       }
  268.  
  269.       return null;
  270.    }
  271.  
  272.    public V put(K var1, V var2) {
  273.       Entry var3 = this.root;
  274.       if (var3 == null) {
  275.          this.root = new Entry(var1, var2, (Entry)null);
  276.          this.size = 1;
  277.          ++this.modCount;
  278.          return null;
  279.       } else {
  280.          Comparator var6 = this.comparator;
  281.          int var4;
  282.          Entry var5;
  283.          if (var6 != null) {
  284.             do {
  285.                var5 = var3;
  286.                var4 = var6.compare(var1, var3.key);
  287.                if (var4 < 0) {
  288.                   var3 = var3.left;
  289.                } else {
  290.                   if (var4 <= 0) {
  291.                      return (V)var3.setValue(var2);
  292.                   }
  293.  
  294.                   var3 = var3.right;
  295.                }
  296.             } while(var3 != null);
  297.          } else {
  298.             if (var1 == null) {
  299.                throw new NullPointerException();
  300.             }
  301.  
  302.             Comparable var7 = (Comparable)var1;
  303.  
  304.             do {
  305.                var5 = var3;
  306.                var4 = var7.compareTo(var3.key);
  307.                if (var4 < 0) {
  308.                   var3 = var3.left;
  309.                } else {
  310.                   if (var4 <= 0) {
  311.                      return (V)var3.setValue(var2);
  312.                   }
  313.  
  314.                   var3 = var3.right;
  315.                }
  316.             } while(var3 != null);
  317.          }
  318.  
  319.          Entry var8 = new Entry(var1, var2, var5);
  320.          if (var4 < 0) {
  321.             var5.left = var8;
  322.          } else {
  323.             var5.right = var8;
  324.          }
  325.  
  326.          this.fixAfterInsertion(var8);
  327.          ++this.size;
  328.          ++this.modCount;
  329.          return null;
  330.       }
  331.    }
  332.  
  333.    public V remove(Object var1) {
  334.       Entry var2 = this.getEntry(var1);
  335.       if (var2 == null) {
  336.          return null;
  337.       } else {
  338.          Object var3 = var2.value;
  339.          this.deleteEntry(var2);
  340.          return (V)var3;
  341.       }
  342.    }
  343.  
  344.    public void clear() {
  345.       ++this.modCount;
  346.       this.size = 0;
  347.       this.root = null;
  348.    }
  349.  
  350.    public Object clone() {
  351.       Object var1 = null;
  352.  
  353.       try {
  354.          var6 = (TreeMap)super.clone();
  355.       } catch (CloneNotSupportedException var5) {
  356.          throw new InternalError();
  357.       }
  358.  
  359.       var6.root = null;
  360.       var6.size = 0;
  361.       var6.modCount = 0;
  362.       var6.entrySet = null;
  363.       var6.navigableKeySet = null;
  364.       var6.descendingMap = null;
  365.  
  366.       try {
  367.          var6.buildFromSorted(this.size, this.entrySet().iterator(), (ObjectInputStream)null, (Object)null);
  368.       } catch (IOException var3) {
  369.       } catch (ClassNotFoundException var4) {
  370.       }
  371.  
  372.       return var6;
  373.    }
  374.  
  375.    public Map.Entry<K, V> firstEntry() {
  376.       return exportEntry(this.getFirstEntry());
  377.    }
  378.  
  379.    public Map.Entry<K, V> lastEntry() {
  380.       return exportEntry(this.getLastEntry());
  381.    }
  382.  
  383.    public Map.Entry<K, V> pollFirstEntry() {
  384.       Entry var1 = this.getFirstEntry();
  385.       Map.Entry var2 = exportEntry(var1);
  386.       if (var1 != null) {
  387.          this.deleteEntry(var1);
  388.       }
  389.  
  390.       return var2;
  391.    }
  392.  
  393.    public Map.Entry<K, V> pollLastEntry() {
  394.       Entry var1 = this.getLastEntry();
  395.       Map.Entry var2 = exportEntry(var1);
  396.       if (var1 != null) {
  397.          this.deleteEntry(var1);
  398.       }
  399.  
  400.       return var2;
  401.    }
  402.  
  403.    public Map.Entry<K, V> lowerEntry(K var1) {
  404.       return exportEntry(this.getLowerEntry(var1));
  405.    }
  406.  
  407.    public K lowerKey(K var1) {
  408.       return (K)keyOrNull(this.getLowerEntry(var1));
  409.    }
  410.  
  411.    public Map.Entry<K, V> floorEntry(K var1) {
  412.       return exportEntry(this.getFloorEntry(var1));
  413.    }
  414.  
  415.    public K floorKey(K var1) {
  416.       return (K)keyOrNull(this.getFloorEntry(var1));
  417.    }
  418.  
  419.    public Map.Entry<K, V> ceilingEntry(K var1) {
  420.       return exportEntry(this.getCeilingEntry(var1));
  421.    }
  422.  
  423.    public K ceilingKey(K var1) {
  424.       return (K)keyOrNull(this.getCeilingEntry(var1));
  425.    }
  426.  
  427.    public Map.Entry<K, V> higherEntry(K var1) {
  428.       return exportEntry(this.getHigherEntry(var1));
  429.    }
  430.  
  431.    public K higherKey(K var1) {
  432.       return (K)keyOrNull(this.getHigherEntry(var1));
  433.    }
  434.  
  435.    public Set<K> keySet() {
  436.       return this.navigableKeySet();
  437.    }
  438.  
  439.    public NavigableSet<K> navigableKeySet() {
  440.       KeySet var1 = this.navigableKeySet;
  441.       return var1 != null ? var1 : (this.navigableKeySet = new KeySet(this));
  442.    }
  443.  
  444.    public NavigableSet<K> descendingKeySet() {
  445.       return this.descendingMap().navigableKeySet();
  446.    }
  447.  
  448.    public Collection<V> values() {
  449.       Collection var1 = this.values;
  450.       return var1 != null ? var1 : (this.values = new Values(this));
  451.    }
  452.  
  453.    public Set<Map.Entry<K, V>> entrySet() {
  454.       EntrySet var1 = this.entrySet;
  455.       return var1 != null ? var1 : (this.entrySet = new EntrySet(this));
  456.    }
  457.  
  458.    public NavigableMap<K, V> descendingMap() {
  459.       NavigableMap var1 = this.descendingMap;
  460.       return var1 != null ? var1 : (this.descendingMap = new DescendingSubMap(this, true, (Object)null, true, true, (Object)null, true));
  461.    }
  462.  
  463.    public NavigableMap<K, V> subMap(K var1, boolean var2, K var3, boolean var4) {
  464.       return new AscendingSubMap(this, false, var1, var2, false, var3, var4);
  465.    }
  466.  
  467.    public NavigableMap<K, V> headMap(K var1, boolean var2) {
  468.       return new AscendingSubMap(this, true, (Object)null, true, false, var1, var2);
  469.    }
  470.  
  471.    public NavigableMap<K, V> tailMap(K var1, boolean var2) {
  472.       return new AscendingSubMap(this, false, var1, var2, true, (Object)null, true);
  473.    }
  474.  
  475.    public SortedMap<K, V> subMap(K var1, K var2) {
  476.       return this.subMap(var1, true, var2, false);
  477.    }
  478.  
  479.    public SortedMap<K, V> headMap(K var1) {
  480.       return this.headMap(var1, false);
  481.    }
  482.  
  483.    public SortedMap<K, V> tailMap(K var1) {
  484.       return this.tailMap(var1, true);
  485.    }
  486.  
  487.    Iterator<K> keyIterator() {
  488.       return new KeyIterator(this, this.getFirstEntry());
  489.    }
  490.  
  491.    Iterator<K> descendingKeyIterator() {
  492.       return new DescendingKeyIterator(this, this.getFirstEntry());
  493.    }
  494.  
  495.    final int compare(Object var1, Object var2) {
  496.       return this.comparator == null ? ((Comparable)var1).compareTo(var2) : this.comparator.compare(var1, var2);
  497.    }
  498.  
  499.    static final boolean valEquals(Object var0, Object var1) {
  500.       return var0 == null ? var1 == null : var0.equals(var1);
  501.    }
  502.  
  503.    static <K, V> Map.Entry<K, V> exportEntry(Entry<K, V> var0) {
  504.       return var0 == null ? null : new AbstractMap.SimpleImmutableEntry(var0);
  505.    }
  506.  
  507.    static <K, V> K keyOrNull(Entry<K, V> var0) {
  508.       return (K)(var0 == null ? null : var0.key);
  509.    }
  510.  
  511.    static <K> K key(Entry<K, ?> var0) {
  512.       if (var0 == null) {
  513.          throw new NoSuchElementException();
  514.       } else {
  515.          return (K)var0.key;
  516.       }
  517.    }
  518.  
  519.    final Entry<K, V> getFirstEntry() {
  520.       Entry var1 = this.root;
  521.       if (var1 != null) {
  522.          while(var1.left != null) {
  523.             var1 = var1.left;
  524.          }
  525.       }
  526.  
  527.       return var1;
  528.    }
  529.  
  530.    final Entry<K, V> getLastEntry() {
  531.       Entry var1 = this.root;
  532.       if (var1 != null) {
  533.          while(var1.right != null) {
  534.             var1 = var1.right;
  535.          }
  536.       }
  537.  
  538.       return var1;
  539.    }
  540.  
  541.    static <K, V> Entry<K, V> successor(Entry<K, V> var0) {
  542.       if (var0 == null) {
  543.          return null;
  544.       } else if (var0.right != null) {
  545.          Entry var3;
  546.          for(var3 = var0.right; var3.left != null; var3 = var3.left) {
  547.          }
  548.  
  549.          return var3;
  550.       } else {
  551.          Entry var1 = var0.parent;
  552.  
  553.          for(Entry var2 = var0; var1 != null && var2 == var1.right; var1 = var1.parent) {
  554.             var2 = var1;
  555.          }
  556.  
  557.          return var1;
  558.       }
  559.    }
  560.  
  561.    static <K, V> Entry<K, V> predecessor(Entry<K, V> var0) {
  562.       if (var0 == null) {
  563.          return null;
  564.       } else if (var0.left != null) {
  565.          Entry var3;
  566.          for(var3 = var0.left; var3.right != null; var3 = var3.right) {
  567.          }
  568.  
  569.          return var3;
  570.       } else {
  571.          Entry var1 = var0.parent;
  572.  
  573.          for(Entry var2 = var0; var1 != null && var2 == var1.left; var1 = var1.parent) {
  574.             var2 = var1;
  575.          }
  576.  
  577.          return var1;
  578.       }
  579.    }
  580.  
  581.    private static <K, V> boolean colorOf(Entry<K, V> var0) {
  582.       return var0 == null ? true : var0.color;
  583.    }
  584.  
  585.    private static <K, V> Entry<K, V> parentOf(Entry<K, V> var0) {
  586.       return var0 == null ? null : var0.parent;
  587.    }
  588.  
  589.    private static <K, V> void setColor(Entry<K, V> var0, boolean var1) {
  590.       if (var0 != null) {
  591.          var0.color = var1;
  592.       }
  593.  
  594.    }
  595.  
  596.    private static <K, V> Entry<K, V> leftOf(Entry<K, V> var0) {
  597.       return var0 == null ? null : var0.left;
  598.    }
  599.  
  600.    private static <K, V> Entry<K, V> rightOf(Entry<K, V> var0) {
  601.       return var0 == null ? null : var0.right;
  602.    }
  603.  
  604.    private void rotateLeft(Entry<K, V> var1) {
  605.       if (var1 != null) {
  606.          Entry var2 = var1.right;
  607.          var1.right = var2.left;
  608.          if (var2.left != null) {
  609.             var2.left.parent = var1;
  610.          }
  611.  
  612.          var2.parent = var1.parent;
  613.          if (var1.parent == null) {
  614.             this.root = var2;
  615.          } else if (var1.parent.left == var1) {
  616.             var1.parent.left = var2;
  617.          } else {
  618.             var1.parent.right = var2;
  619.          }
  620.  
  621.          var2.left = var1;
  622.          var1.parent = var2;
  623.       }
  624.  
  625.    }
  626.  
  627.    private void rotateRight(Entry<K, V> var1) {
  628.       if (var1 != null) {
  629.          Entry var2 = var1.left;
  630.          var1.left = var2.right;
  631.          if (var2.right != null) {
  632.             var2.right.parent = var1;
  633.          }
  634.  
  635.          var2.parent = var1.parent;
  636.          if (var1.parent == null) {
  637.             this.root = var2;
  638.          } else if (var1.parent.right == var1) {
  639.             var1.parent.right = var2;
  640.          } else {
  641.             var1.parent.left = var2;
  642.          }
  643.  
  644.          var2.right = var1;
  645.          var1.parent = var2;
  646.       }
  647.  
  648.    }
  649.  
  650.    private void fixAfterInsertion(Entry<K, V> var1) {
  651.       var1.color = false;
  652.  
  653.       while(var1 != null && var1 != this.root && !var1.parent.color) {
  654.          if (parentOf(var1) == leftOf(parentOf(parentOf(var1)))) {
  655.             Entry var2 = rightOf(parentOf(parentOf(var1)));
  656.             if (!colorOf(var2)) {
  657.                setColor(parentOf(var1), true);
  658.                setColor(var2, true);
  659.                setColor(parentOf(parentOf(var1)), false);
  660.                var1 = parentOf(parentOf(var1));
  661.             } else {
  662.                if (var1 == rightOf(parentOf(var1))) {
  663.                   var1 = parentOf(var1);
  664.                   this.rotateLeft(var1);
  665.                }
  666.  
  667.                setColor(parentOf(var1), true);
  668.                setColor(parentOf(parentOf(var1)), false);
  669.                this.rotateRight(parentOf(parentOf(var1)));
  670.             }
  671.          } else {
  672.             Entry var3 = leftOf(parentOf(parentOf(var1)));
  673.             if (!colorOf(var3)) {
  674.                setColor(parentOf(var1), true);
  675.                setColor(var3, true);
  676.                setColor(parentOf(parentOf(var1)), false);
  677.                var1 = parentOf(parentOf(var1));
  678.             } else {
  679.                if (var1 == leftOf(parentOf(var1))) {
  680.                   var1 = parentOf(var1);
  681.                   this.rotateRight(var1);
  682.                }
  683.  
  684.                setColor(parentOf(var1), true);
  685.                setColor(parentOf(parentOf(var1)), false);
  686.                this.rotateLeft(parentOf(parentOf(var1)));
  687.             }
  688.          }
  689.       }
  690.  
  691.       this.root.color = true;
  692.    }
  693.  
  694.    private void deleteEntry(Entry<K, V> var1) {
  695.       ++this.modCount;
  696.       --this.size;
  697.       if (var1.left != null && var1.right != null) {
  698.          Entry var2 = successor(var1);
  699.          var1.key = var2.key;
  700.          var1.value = var2.value;
  701.          var1 = var2;
  702.       }
  703.  
  704.       Entry var3 = var1.left != null ? var1.left : var1.right;
  705.       if (var3 != null) {
  706.          var3.parent = var1.parent;
  707.          if (var1.parent == null) {
  708.             this.root = var3;
  709.          } else if (var1 == var1.parent.left) {
  710.             var1.parent.left = var3;
  711.          } else {
  712.             var1.parent.right = var3;
  713.          }
  714.  
  715.          var1.left = var1.right = var1.parent = null;
  716.          if (var1.color) {
  717.             this.fixAfterDeletion(var3);
  718.          }
  719.       } else if (var1.parent == null) {
  720.          this.root = null;
  721.       } else {
  722.          if (var1.color) {
  723.             this.fixAfterDeletion(var1);
  724.          }
  725.  
  726.          if (var1.parent != null) {
  727.             if (var1 == var1.parent.left) {
  728.                var1.parent.left = null;
  729.             } else if (var1 == var1.parent.right) {
  730.                var1.parent.right = null;
  731.             }
  732.  
  733.             var1.parent = null;
  734.          }
  735.       }
  736.  
  737.    }
  738.  
  739.    private void fixAfterDeletion(Entry<K, V> var1) {
  740.       while(var1 != this.root && colorOf(var1)) {
  741.          if (var1 == leftOf(parentOf(var1))) {
  742.             Entry var3 = rightOf(parentOf(var1));
  743.             if (!colorOf(var3)) {
  744.                setColor(var3, true);
  745.                setColor(parentOf(var1), false);
  746.                this.rotateLeft(parentOf(var1));
  747.                var3 = rightOf(parentOf(var1));
  748.             }
  749.  
  750.             if (colorOf(leftOf(var3)) && colorOf(rightOf(var3))) {
  751.                setColor(var3, false);
  752.                var1 = parentOf(var1);
  753.             } else {
  754.                if (colorOf(rightOf(var3))) {
  755.                   setColor(leftOf(var3), true);
  756.                   setColor(var3, false);
  757.                   this.rotateRight(var3);
  758.                   var3 = rightOf(parentOf(var1));
  759.                }
  760.  
  761.                setColor(var3, colorOf(parentOf(var1)));
  762.                setColor(parentOf(var1), true);
  763.                setColor(rightOf(var3), true);
  764.                this.rotateLeft(parentOf(var1));
  765.                var1 = this.root;
  766.             }
  767.          } else {
  768.             Entry var2 = leftOf(parentOf(var1));
  769.             if (!colorOf(var2)) {
  770.                setColor(var2, true);
  771.                setColor(parentOf(var1), false);
  772.                this.rotateRight(parentOf(var1));
  773.                var2 = leftOf(parentOf(var1));
  774.             }
  775.  
  776.             if (colorOf(rightOf(var2)) && colorOf(leftOf(var2))) {
  777.                setColor(var2, false);
  778.                var1 = parentOf(var1);
  779.             } else {
  780.                if (colorOf(leftOf(var2))) {
  781.                   setColor(rightOf(var2), true);
  782.                   setColor(var2, false);
  783.                   this.rotateLeft(var2);
  784.                   var2 = leftOf(parentOf(var1));
  785.                }
  786.  
  787.                setColor(var2, colorOf(parentOf(var1)));
  788.                setColor(parentOf(var1), true);
  789.                setColor(leftOf(var2), true);
  790.                this.rotateRight(parentOf(var1));
  791.                var1 = this.root;
  792.             }
  793.          }
  794.       }
  795.  
  796.       setColor(var1, true);
  797.    }
  798.  
  799.    private void writeObject(ObjectOutputStream var1) throws IOException {
  800.       var1.defaultWriteObject();
  801.       var1.writeInt(this.size);
  802.  
  803.       for(Map.Entry var3 : this.entrySet()) {
  804.          var1.writeObject(var3.getKey());
  805.          var1.writeObject(var3.getValue());
  806.       }
  807.  
  808.    }
  809.  
  810.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  811.       var1.defaultReadObject();
  812.       int var2 = var1.readInt();
  813.       this.buildFromSorted(var2, (Iterator)null, var1, (Object)null);
  814.    }
  815.  
  816.    void readTreeSet(int var1, ObjectInputStream var2, V var3) throws IOException, ClassNotFoundException {
  817.       this.buildFromSorted(var1, (Iterator)null, var2, var3);
  818.    }
  819.  
  820.    void addAllForTreeSet(SortedSet<? extends K> var1, V var2) {
  821.       try {
  822.          this.buildFromSorted(var1.size(), var1.iterator(), (ObjectInputStream)null, var2);
  823.       } catch (IOException var4) {
  824.       } catch (ClassNotFoundException var5) {
  825.       }
  826.  
  827.    }
  828.  
  829.    private void buildFromSorted(int var1, Iterator var2, ObjectInputStream var3, V var4) throws IOException, ClassNotFoundException {
  830.       this.size = var1;
  831.       this.root = this.buildFromSorted(0, 0, var1 - 1, computeRedLevel(var1), var2, var3, var4);
  832.    }
  833.  
  834.    private final Entry<K, V> buildFromSorted(int var1, int var2, int var3, int var4, Iterator var5, ObjectInputStream var6, V var7) throws IOException, ClassNotFoundException {
  835.       if (var3 < var2) {
  836.          return null;
  837.       } else {
  838.          int var8 = (var2 + var3) / 2;
  839.          Entry var9 = null;
  840.          if (var2 < var8) {
  841.             var9 = this.buildFromSorted(var1 + 1, var2, var8 - 1, var4, var5, var6, var7);
  842.          }
  843.  
  844.          Object var10;
  845.          Object var11;
  846.          if (var5 != null) {
  847.             if (var7 == null) {
  848.                Map.Entry var12 = (Map.Entry)var5.next();
  849.                var10 = var12.getKey();
  850.                var11 = var12.getValue();
  851.             } else {
  852.                var10 = var5.next();
  853.                var11 = var7;
  854.             }
  855.          } else {
  856.             var10 = var6.readObject();
  857.             var11 = var7 != null ? var7 : var6.readObject();
  858.          }
  859.  
  860.          Entry var14 = new Entry(var10, var11, (Entry)null);
  861.          if (var1 == var4) {
  862.             var14.color = false;
  863.          }
  864.  
  865.          if (var9 != null) {
  866.             var14.left = var9;
  867.             var9.parent = var14;
  868.          }
  869.  
  870.          if (var8 < var3) {
  871.             Entry var13 = this.buildFromSorted(var1 + 1, var8 + 1, var3, var4, var5, var6, var7);
  872.             var14.right = var13;
  873.             var13.parent = var14;
  874.          }
  875.  
  876.          return var14;
  877.       }
  878.    }
  879.  
  880.    private static int computeRedLevel(int var0) {
  881.       int var1 = 0;
  882.  
  883.       for(int var2 = var0 - 1; var2 >= 0; var2 = var2 / 2 - 1) {
  884.          ++var1;
  885.       }
  886.  
  887.       return var1;
  888.    }
  889.  
  890.    // $FF: synthetic method
  891.    static void access$000(TreeMap var0, Entry var1) {
  892.       var0.deleteEntry(var1);
  893.    }
  894.  
  895.    // $FF: synthetic method
  896.    static int access$100(TreeMap var0) {
  897.       return var0.modCount;
  898.    }
  899.  
  900.    // $FF: synthetic method
  901.    static Comparator access$200(TreeMap var0) {
  902.       return var0.comparator;
  903.    }
  904. }
  905.